#include "ventanaprincipal.h"
#include "CartaDeObjetivos.h"
#include "imapa.h"
#include <sstream>

#define TAB_ROWS 32
#define TAB_COLS 32

using namespace ui::tablero::mapa;

namespace ui {

VentanaPrincipal::VentanaPrincipal(const Glib::RefPtr<const Gdk::GL::Config>& p_Config, JuegoClientImp &jClient, Jugador &jug) :
	Window(WINDOW_TOPLEVEL),
	m_tabPrincipal(TAB_ROWS, TAB_COLS, false),
	m_drwTablero(p_Config, jClient.getMapa()),
	jugador(jug),
	jCliente(jClient),
	msgError(*this,"Acción invalida",false,Gtk::MESSAGE_INFO,	Gtk::BUTTONS_OK,false),
	msgFinalizacion(*this,"La partida ha finalizado",false,Gtk::MESSAGE_INFO,	Gtk::BUTTONS_OK,false),
	msgSolicitud(*this,jCliente, jugador),
	msgDadosResultantes(*this)
{
	territorioSeleccionado = false;
	
	this->m_drwTablero.signal_button_press_event().connect(sigc::mem_fun(*this,
					            &VentanaPrincipal::on_imagen_clicked));
	
	this->set_position(WIN_POS_CENTER);
	this->maximize();

	//Create actions for menus and toolbars:
	this->m_refActionGroup = Gtk::ActionGroup::create();

	this->m_refActionGroup->add(Gtk::Action::create("mnuJuego", "Juego"));
	this->m_refActionGroup->add(Gtk::Action::create("mnuJuegoSalir", "Salir"),
		Gtk::AccelKey("<control>S"),
		sigc::mem_fun(*this, &VentanaPrincipal::on_menu_JuegoSalir));

	this->m_refActionGroup->add(Gtk::Action::create("mnuMapa", "Mapa"));
	this->m_refActionGroup->add(Gtk::Action::create("mnuMapaEsferico", "Esferico"),
		Gtk::AccelKey("<control>E"),
		sigc::mem_fun(*this, &VentanaPrincipal::on_menu_MapaEsferico));
	this->m_refActionGroup->add(Gtk::Action::create("mnuMapaPlano", "Plano"),
		Gtk::AccelKey("<control>P"),
		sigc::mem_fun(*this, &VentanaPrincipal::on_menu_MapaPlano));

	this->m_refUIManager = Gtk::UIManager::create();
	this->m_refUIManager->insert_action_group(m_refActionGroup);

	Glib::ustring ui_info = 
		"<ui>"
		"  <menubar name='MenuBar'>"
		"    <menu action='mnuJuego'>"
		"      <menuitem action='mnuJuegoSalir'/>"
		"    </menu>"
		"    <menu action='mnuMapa'>"
		"      <menuitem action='mnuMapaEsferico'/>"
		"      <menuitem action='mnuMapaPlano'/>"
		"    </menu>"
		"  </menubar>"
		"</ui>";

	this->add_accel_group(m_refUIManager->get_accel_group());
	this->m_refUIManager->add_ui_from_string(ui_info);
	Gtk::Widget* pMenubar = m_refUIManager->get_widget("/MenuBar");

	//OTRO
	this->m_frmOtro.set_label("RISK");
	this->m_frmOtro.set_label_align(Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP);
	this->m_frmOtro.set_shadow_type(Gtk::SHADOW_ETCHED_OUT);
	//Estadisticas
	this->m_frmEstadisticas.set_label("Estadisticas");
	this->m_frmEstadisticas.set_label_align(Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP);
	this->m_frmEstadisticas.set_shadow_type(Gtk::SHADOW_ETCHED_OUT);
	this->estadisticasSalida.set_editable(false);
	this->m_frmEstadisticas.add(estadisticasSalida);
	this->otroVBox.pack_start(m_frmEstadisticas, true, true, 10);
	//Mision
	this->m_frmMision.set_label("Mision");
	this->m_frmMision.set_label_align(Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP);
	this->m_frmMision.set_shadow_type(Gtk::SHADOW_ETCHED_OUT);
	this->misionBoton.set_label("Ver Misión");
	misionBoton.signal_clicked().connect( sigc::mem_fun(*this,
						            &VentanaPrincipal::on_mision_boton_clicked));
	this->misionBox.pack_start(misionBoton);
	this->m_frmMision.add(misionBox);
	this->otroVBox.pack_start(m_frmMision,false,true,10);
	//Boton Mapa
	this->m_frmBotonMapa.set_label("Mapa");
	this->m_frmOtro.set_label_align(Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP);
	this->m_frmOtro.set_shadow_type(Gtk::SHADOW_ETCHED_OUT);
	this->mapaBoton.set_label("Cambiar Vista");
	mapaBoton.signal_clicked().connect( sigc::mem_fun(*this,
					            &VentanaPrincipal::on_mapa_boton_clicked));
	this->mapaBox.pack_start(mapaBoton);
	this->m_frmBotonMapa.add(mapaBox);
	this->otroVBox.pack_start(m_frmBotonMapa,false,true,10);
	//Estado
	this->m_frmEstado.set_label("Acciones");
	this->m_frmEstado.set_label_align(Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP);
	this->m_frmEstado.set_shadow_type(Gtk::SHADOW_ETCHED_OUT);
	this->estadoBoton.set_label("Esperando Jugadores");
	this->estadoBoton.set_sensitive(false);
	estadoBoton.signal_clicked().connect( sigc::mem_fun(*this,
						            &VentanaPrincipal::on_estado_boton_clicked));
	estadoJuego = ESTADO_NO_TURNO;
	this->estadoBox.pack_start(estadoBoton);
	this->m_frmEstado.add(estadoBox);
	this->otroVBox.pack_start(m_frmEstado, false, true, 10);
	
	this->m_frmOtro.add(otroVBox);
	
	//CHAT
	this->m_frmChat.set_label("Chat");
	this->m_frmChat.set_label_align(Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP);
	this->m_frmChat.set_shadow_type(Gtk::SHADOW_ETCHED_OUT);
	this->hBoxChat.pack_start(this->chatEntrada, true, true,0);
	this->chatEntrada.set_editable(true);
	this->hBoxChat.pack_start(this->chatBotonEnviar, false, true, 0);
	chatBotonEnviar.signal_clicked().connect( sigc::mem_fun(*this,
				            &VentanaPrincipal::on_enviar_clicked));
	chatBotonEnviar.set_state(Gtk::STATE_PRELIGHT);
	this->chatBotonEnviar.set_label("Enviar");
	this->vBoxChat.pack_start(this->chatS1, false, false, 0);
	this->chatBarra.add(chatSalida);
	this->chatBarra.get_hscrollbar()->hide();
	this->vBoxChat.pack_start(this->chatBarra, true, true, 0);
	this->chatSalida.set_editable(false);
	this->vBoxChat.pack_start(this->chatS2, false, false, 0);
	this->vBoxChat.pack_start(this->hBoxChat, false, true, 0);
	this->m_frmChat.add(vBoxChat);
	
	//INFORMACION
	this->m_frmInfo.set_label("Info");
	this->m_frmInfo.set_label_align(Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP);
	this->m_frmInfo.set_shadow_type(Gtk::SHADOW_ETCHED_OUT);
	this->infoSalida.set_editable(false);
	this->infoBarra.add(infoSalida);
	this->m_frmInfo.add(infoBarra);
	this->jCliente.addObserver(&infoSalida);
	this->m_tabPrincipal.attach(*pMenubar, 0, 32, 0, 1,
		Gtk::FILL | Gtk::SHRINK, Gtk::FILL | Gtk::SHRINK, 0, 0);
	this->m_tabPrincipal.attach(this->m_drwTablero, 0, 24, 1, 23,
		Gtk::FILL | Gtk::SHRINK, Gtk::FILL | Gtk::SHRINK, 0, 0);
	this->m_tabPrincipal.attach(this->m_frmOtro, 24, 32, 1, 23,
		Gtk::FILL | Gtk::EXPAND, Gtk::FILL | Gtk::EXPAND, 0, 0);
	this->m_tabPrincipal.attach(this->m_frmChat, 0, 12, 23, 32,
		Gtk::FILL | Gtk::EXPAND, Gtk::FILL | Gtk::EXPAND, 0, 0);
	this->m_tabPrincipal.attach(this->m_frmInfo, 12, 32, 23, 32,
		Gtk::FILL | Gtk::EXPAND, Gtk::FILL | Gtk::EXPAND, 0, 0);
	this->add(this->m_tabPrincipal);
	
	this->signal_delete_event().connect(sigc::mem_fun(*this, 
			&VentanaPrincipal::on_ventana_close));

}

bool VentanaPrincipal :: on_ventana_close(GdkEventAny* event){
	jCliente.abandonar(&jugador);
	this->hide();
	Gtk::Main::quit();
	return false;
}

void VentanaPrincipal::update() {
	if (dynamic_cast<JuegoClientImp*>(this->observable) != 0) {
		JuegoClientImp* juego = dynamic_cast<JuegoClientImp*>(this->observable);
		if(jCliente.isEnEstadoDePartidaFinalizada()){
			this->estadoBoton.set_sensitive(false);
			this->estadoBoton.set_label("Juego Finalizado");
			this->infoSalida.borrar();
			this->infoSalida.escribir("Juego terminado.");
		}
		else if(juego->getJugadorEnTurno()->getColor() == jugador.getColor()){
			setEstadoActual();
			this->estadoBoton.set_label("ES TU TURNO");
		}
		else{
			this->estadoBoton.set_sensitive(false);
			this->estadoBoton.set_label("No es tu turno");
		}
		escribirEstadisticas(juego);
	}
}

void VentanaPrincipal :: mostrar(){
	mapa = jCliente.getMapa();
	if(jCliente.isEnEstadoDeEsperaDeJugadores()){
		this->infoSalida.escribir("Esperando que se conecten los otros jugadores.");
	}
	if(jCliente.isEnEstadoDePreparacion()){
		this->infoSalida.escribir("Ha comenzado el estado de preparación de partida.");
	}
	this->jCliente.addObserver(this);
	this->jCliente.getCliente()->getBuzonDeMensajesDeChat()->addObserver(&chatSalida);
	this->jCliente.getCliente()->getBuzonDeMensajesDeExcepcion()->addObserver(&msgError);
	this->jCliente.getCliente()->getBuzonDeMensajesDeFinalizacion()->addObserver(&msgFinalizacion);
	this->jCliente.getCliente()->getBuzonDeMensajesDeSolicitud()->addObserver(&msgSolicitud);
	this->jCliente.getCliente()->getBuzonDeMensajesMostrarDados()->addObserver(&msgDadosResultantes);
	this->mapa->addObserver(&m_drwTablero);
	
	if(jCliente.isEnEstadoDePreparacion()){
		this->infoSalida.escribir("Es el turno de "+jCliente.getJugadorEnTurno()->getNombre());
		if(jCliente.getJugadorEnTurno()->getColor() != jugador.getColor()){
			this->estadoBoton.set_sensitive(false);
			this->estadoBoton.set_label("No es tu turno");
		}
	}
	this->set_title("RISK 3D - "+jugador.getNombre()+" - "+jugador.getColor());
	this->show_all();
	Gtk::Main::run();
}

void VentanaPrincipal :: setEstadoActual(){
	if(jCliente.isEnEstadoDePreparacion()){
		this->estadoJuego = ESTADO_SELECCION_PAISES;
		std::stringstream ejercitos;
		ejercitos<<jugador.getCantidadDeEjercitos();		
		infoSalida.escribir("Te quedan "+ejercitos.str()+" para colocar.");
		infoSalida.escribir("Seleccione el país que desees.");
	}
	else if(jCliente.isEstadoDeRefuerzoYReubicacion()){
		std::stringstream ejercitos;
		ejercitos<<jugador.getCantidadDeEjercitos();		
		infoSalida.escribir("Te quedan "+ejercitos.str()+" para colocar.");
		this->estadoJuego = ESTADO_REFUERZO;
		infoSalida.escribir("Seleccione el país que quiere fortificar.");
	}
	else if(jCliente.isEnEstadoDeAtaque()){
		this->estadoJuego = ESTADO_ATAQUE;
		infoSalida.escribir("Seleccione el ataque deseado.");
		estadoBoton.set_sensitive(true);
		estadoBoton.set_label("Fortificar");
	}
	else if(jCliente.isEnEstadoDeFortificacionDeUnidades()){
		this->estadoJuego = ESTADO_FORTIFICACION;
		infoSalida.escribir("Seleccione el traspazo de tropas.");
		estadoBoton.set_sensitive(true);
		estadoBoton.set_label("Pasar");
	}
}

VentanaPrincipal::~VentanaPrincipal() {
	this->jCliente.deleteObserver(this);
	this->jCliente.deleteObserver(&infoSalida);
	this->jCliente.getCliente()->getBuzonDeMensajesDeChat()->deleteObserver(&chatSalida);
	this->jCliente.getCliente()->getBuzonDeMensajesDeExcepcion()->deleteObserver(&msgError);
	this->jCliente.getCliente()->getBuzonDeMensajesDeFinalizacion()->deleteObserver(&msgFinalizacion);
	this->jCliente.getCliente()->getBuzonDeMensajesDeSolicitud()->deleteObserver(&msgSolicitud);
	this->jCliente.getCliente()->getBuzonDeMensajesMostrarDados()->deleteObserver(&msgDadosResultantes);
	this->mapa->deleteObserver(&m_drwTablero);
}

bool VentanaPrincipal :: on_imagen_clicked(GdkEventButton *event){
	
	if(jCliente.getEstado() != "EstadoDeEsperaDeJugadores"){
	
		Jugador *jTurno = jCliente.getJugadorEnTurno();
		string colorTurno = jTurno->getColor();	
		string colorJugador = jugador.getColor();
	
		if(colorTurno == colorJugador){
	
			string terr, cont;
			if(m_drwTablero.getTerritorioSeleccionado(terr, cont)){
				Continente *c = mapa->obtenerContinente(cont);
				Territorio *t = c->getTerritorio(terr);
				setEstadoActual();
				switch(estadoJuego){
					case (ESTADO_SELECCION_PAISES): 
							jCliente.colocarEjercitos(&jugador, t, 1);
							break; 
					case (ESTADO_REFUERZO): 
							jCliente.colocarEjercitos(&jugador, t, 1);
							break;
					case (ESTADO_ATAQUE): 
						estadoAtaque(*t);
						break;
		
					case (ESTADO_FORTIFICACION): 
						estadoFortificacion(*t);
						break;
	
				}
			}
		}
	}
	return true;
}

void VentanaPrincipal :: estadoAtaque(Territorio &t){
	
	string color;
	color = t.getEnPoderDe();
	
	if(!territorioSeleccionado){
		
		if(color.compare(jugador.getColor()) == 0){
			territorioSeleccionado = true;
			territorioDesde = &t;
		}
	}
	else{
		if(color.compare(jugador.getColor()) != 0){
			if(t.esAdyacente(territorioDesde)){
				int cantEjercitosPosibles;
				if(territorioDesde->getCantidadDeEjercitos() > 3){
					cantEjercitosPosibles = 3;
				}
				else{
					cantEjercitosPosibles = territorioDesde->getCantidadDeEjercitos()-1;
				}
				int cantDados;
				if(msgDados(cantEjercitosPosibles, cantDados, territorioDesde->getNombre(), t.getNombre())){
					Ataque ataque(&jugador, territorioDesde, &t, cantDados);
					jCliente.realizarAtaque(&ataque);
				}
				territorioSeleccionado = false;
			}
			else{
				msgError.correr(t.getNombre()+" no es limitrofe de "+territorioDesde->getNombre());
			}
		}
		else{
			territorioSeleccionado = false;
			estadoAtaque(t);
		}
		
	}
}

void VentanaPrincipal :: estadoFortificacion(Territorio &t){
	
	string color;
	color = t.getEnPoderDe();
	
	if(!territorioSeleccionado){
		
		if(color.compare(jugador.getColor()) == 0){
			territorioSeleccionado = true;
			territorioDesde = &t;
		}
	}
	else{
		if(color.compare(jugador.getColor()) == 0){
			if(t.esAdyacente(territorioDesde)){
				int cantEjercitosPosibles = territorioDesde->getCantidadDeEjercitos()-1;
				int cantEjercitos;
				if(msgFortificacion(cantEjercitosPosibles, cantEjercitos, territorioDesde->getNombre(), t.getNombre())){
					jCliente.moverEjercitos(&jugador, territorioDesde, &t, cantEjercitos);
				}
				territorioSeleccionado = false;
			}
			else{
				msgError.correr(t.getNombre()+" no es limitrofe de "+territorioDesde->getNombre());
			}
		}
		else{
			territorioSeleccionado = false;
			estadoFortificacion(t);
		}
		
	}
}

bool VentanaPrincipal::on_key_press_event(GdkEventKey *event) {

	if(this->m_drwTablero.on_key_press_event(event) == false){
		this->chatEntrada.on_key_press(event);
	}
	return true;
}

void VentanaPrincipal :: on_enviar_clicked(){
	
	if(this->chatEntrada.get_text().compare("") != 0){
		string msg;
		msg.assign(jugador.getNombre()+" > "+chatEntrada.get_text());
		this->chatSalida.escribir(msg);
		this->jCliente.getCliente()->enviarMensajeChat(this->chatEntrada.get_text());
		this->chatEntrada.set_text("");
	}
	return;
}

void VentanaPrincipal :: on_mapa_boton_clicked(){
	if(this->m_drwTablero.get_tipo_mapa() == MAPA_PLANO){
		this->m_drwTablero.cambiarMapa(MAPA_ESFERICO);
	}
	else this->m_drwTablero.cambiarMapa(MAPA_PLANO);
}

void VentanaPrincipal :: on_mision_boton_clicked(){
	verMision();
}

void VentanaPrincipal :: on_estado_boton_clicked(){
	
	territorioSeleccionado = false;
	
	switch(estadoJuego){
		case (ESTADO_NO_TURNO): estadoJuego = ESTADO_REFUERZO;
						  	estadoBoton.set_label("ATACAR");
						  	escribirInfo("--Es tu turno--");
						  	escribirInfo("--Has comenzado el estado de Refuerzo--");
							break;
	
		case (ESTADO_REFUERZO): estadoJuego = ESTADO_ATAQUE;
						  	estadoBoton.set_label("Fortificar");
						  	escribirInfo("--Haz finalizado el estado de Refuerzo--");
						  	escribirInfo("--Has comenzado el estado de Ataque--");
							break;
		case (ESTADO_ATAQUE): 	estadoJuego = ESTADO_FORTIFICACION;
						  	estadoBoton.set_label("Pasar");
						  	jCliente.setEstado("EstadoDeFortificacionDeUnidades");
						  	this->territorioSeleccionado = false;
						  	infoSalida.escribir("--Has finalizado el estado de Ataque--");
						  	infoSalida.escribir("--Has comenzado el estado de Fortificación--");
						  	break;
		case (ESTADO_FORTIFICACION): estadoJuego = ESTADO_NO_TURNO;
							jCliente.pasar(&jugador);
							estadoBoton.set_label("No es tu turno");
							estadoBoton.set_sensitive(false);
							infoSalida.escribir("--Has terminado el estado de Fortificacion--");
							infoSalida.escribir("--Termino tu turno--");
							jCliente.pasar(&this->jugador);
							break;
	}
}

bool VentanaPrincipal::on_delete_event(GdkEventAny *e) {

	return this->bSalir();
}

void VentanaPrincipal::on_menu_JuegoSalir() {
	this->bSalir();
}

bool VentanaPrincipal::bSalir() {
	if(!jCliente.isEnEstadoDePartidaFinalizada())
		jCliente.abandonar(&jugador);
	this->hide();
	Gtk::Main::quit();

	return true;
}

void VentanaPrincipal::on_menu_MapaEsferico() {
	this->m_drwTablero.cambiarMapa(MAPA_ESFERICO);
}

void VentanaPrincipal::on_menu_MapaPlano() {
	this->m_drwTablero.cambiarMapa(MAPA_PLANO);
}

void VentanaPrincipal :: escribirInfo(string msg){
	msg.append("\n");
	infoMsg.append(msg);
	Glib::RefPtr<Gtk::TextBuffer> chatBuffer = Gtk::TextBuffer::create();
	chatBuffer->set_text(infoMsg);
	infoSalida.set_buffer(chatBuffer);
	double upper = infoBarra.get_vadjustment()->get_upper();
	infoBarra.get_vadjustment()->set_value(upper);
	infoBarra.get_vadjustment()->changed();
}

bool VentanaPrincipal :: msgDados(int cantDadosPosibles, int &cantDados, string tDesde, string tHasta){
	Gtk::Dialog dialog("Declaracion de ataque", this);
	dialog.set_modal(true);
	Gtk::HBox hBox;
	Gtk::Label batalla(tDesde+" ataca a "+tHasta);
	Gtk::HSeparator hs;
	Gtk::Label msg("Escoja la cantidad de dados a lanzar: ");
	Gtk::ComboBoxText combo;
	hBox.pack_start(msg,true,false,0);
	hBox.pack_start(combo,false,true,0);
	dialog.get_vbox()->pack_start(batalla);
	dialog.get_vbox()->pack_start(hs);
	dialog.get_vbox()->pack_start(hBox);
	dialog.add_button("Declarar ataque", Gtk::RESPONSE_ACCEPT);
	dialog.add_button("Cancelar", Gtk::RESPONSE_CANCEL);
	
	char cadena[2];
	for(int i = 1; i <= cantDadosPosibles; i++){
		sprintf(cadena,"%d",i); 
		combo.append_text(cadena);
	}
	
	combo.set_active(0);
	
	dialog.show_all();
	int response = dialog.run();
	
	if(response == Gtk::RESPONSE_ACCEPT){
		cantDados = atoi(combo.get_active_text().c_str());
		return true;
	}
	else{
		return false;
	}
}

bool VentanaPrincipal :: msgFortificacion(int cantEjercitosPosibles, int &cantEjercitos, string tDesde, string tHasta){
	Gtk::Dialog dialog("Fortificación de Territorio", this);
	dialog.set_modal(true);
	Gtk::HBox hBox;
	Gtk::Label batalla(tDesde+" mover a "+tHasta);
	Gtk::HSeparator hs;
	Gtk::Label msg2("Escoja la cantidad de ejercitos a mover: ");
	Gtk::ComboBoxText combo;
	hBox.pack_start(msg2,true,false,0);
	hBox.pack_start(combo,false,true,0);
	dialog.get_vbox()->pack_start(batalla);
	dialog.get_vbox()->pack_start(hs);
	dialog.get_vbox()->pack_start(hBox);
	dialog.add_button("Mover", Gtk::RESPONSE_ACCEPT);
	dialog.add_button("Cancelar", Gtk::RESPONSE_CANCEL);
	
	char cadena[2];
	for(int i = 1; i <= cantEjercitosPosibles; i++){
		sprintf(cadena,"%d",i); 
		combo.append_text(cadena);
	}
	combo.set_active(0);
	
	dialog.show_all();
	int response = dialog.run();
	
	if(response == Gtk::RESPONSE_ACCEPT){
		cantEjercitos = atoi(combo.get_active_text().c_str());
		return true;
	}
	else{
		return false;
	}
}

void VentanaPrincipal :: verMision(){
	
	Gtk::MessageDialog dialog(*this,"Mision",false,Gtk::MESSAGE_INFO,
											Gtk::BUTTONS_OK,false);
	
	Gtk::Image imagen;
	
	Glib::RefPtr<Gdk::Pixbuf> pixbuf = Gdk::Pixbuf::create_from_file(PACKAGE_DATA_DIR"/riskclient/images/pergamino.jpg");
		
	if(pixbuf){
		imagen.set(pixbuf);
	}
	
	dialog.set_image(imagen);
	if (this->jugador.getCartaDeObjetivos() != NULL) 
		dialog.set_secondary_text("Objetivo: "+this->jugador.getCartaDeObjetivos()->getObjetivo());
	else
		dialog.set_secondary_text("Todavia no te ha sido asignada una mision.");
	dialog.show_all();
	dialog.run();
}

void VentanaPrincipal :: escribirEstadisticas(JuegoClientImp* j){
	
	vector<Jugador*>* vec = j->getJugadores();
	
	string msg;
	msg += "Cantidad de Territorios\n\n";
	
	for(int i = 0; i < vec->size(); i++){
		Jugador* j = vec->at(i);
		int cantidad = mapa->getTerritoriosEnPoderDeJugador(j->getColor());
		std::stringstream territorios;
		territorios<<cantidad;
		msg += j->getNombre()+" - "+j->getColor()+" = "+territorios.str()+"\n\n";
	}
	
	Glib::RefPtr<Gtk::TextBuffer> estadisticasBuffer = Gtk::TextBuffer::create();
	estadisticasBuffer->set_text(msg);
	estadisticasSalida.set_buffer(estadisticasBuffer);
}



}//end ui

